package dt.inlee.common.encoder.util;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

import dt.inlee.common.constant.CommonConstant;
import dt.inlee.common.util.BaseUtil;

/**
 * @功能说明：日期处理工具类
 * @作者： 许可
 * @创建日期： 2010-6-8 @
 */
public class DateUtil {
    /**
     * 取得指定月份的最后一天
     * 
     * @param strDate -指定日期月份的第一天 比如：2011-01-01
     * @return
     */
    public static String getMonthEnd(String strDate) {
        Date date = DateUtil.stringToDate(strDate);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 1);
        calendar.add(Calendar.DAY_OF_YEAR, -1);
        return DateUtil.dateToString(calendar.getTime(), CommonConstant.DATE_SHORT_FORMAT);
    }

    /**
     * 将给定应用服务器日期按照给定格式化类型转换成字符串
     * 
     * @param date -java日期对象
     * @param format -日期格式化类型
     * @return String -返回转换后的字符串
     */
    public static String dateToString(Date date, String format) {
        if (BaseUtil.isEmpty(date)) date = new Date();
        if (BaseUtil.isEmpty(format)) format = CommonConstant.DATE_WITHMILLISECOND_FORMAT;
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 将给定应用服务器日期按照默认格式化类型转换成字符串
     * 
     * @param date -java日期对象
     * @return String -返回转换后的字符串
     */
    public static String dateToString(Date date) {
        return dateToString(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
    }

    /**
     * 将给定应用服务器日期按照默认格式化类型转换成字符串
     * 
     * @param date -java日期对象
     * @return String -返回转换后的字符串
     */
    public static String shortTimeToString(Date date) {
        return dateToString(date, CommonConstant.DATE_SHORT_TIME_FORMAT);
    }

    /**
     * 将给定应用服务器日期按照默认格式化类型转换成字符串
     * 
     * @param date -java日期对象
     * @return String -返回转换后的字符串
     */
    public static String shortDateToString(Date date) {
        return dateToString(date, CommonConstant.DATE_SHORT_SIMPLE_FORMAT);
    }

    /**
     * 将应用服务器当前日期按照给定格式化类型转换成字符串
     * 
     * @param format -日期格式化类型
     * @return String -返回转换后的字符串
     */
    public static String dateToString(String format) {
        return dateToString(new Date(), format);
    }

    /**
     * 将应用服务器日期按照默认格式化类型转换成字符串
     * 
     * @return String -返回转换后的字符串
     */

    public static String dateToString() {
        return dateToString(new Date(), CommonConstant.DATE_WITHMILLISECOND_FORMAT);
    }

    /**
     * 将字符串转换成日期 注意：一定要选用匹配的格式，否则不能解析，将返回null
     * 
     * @param strDate - 日期
     * @param format - 格式
     * @return Date -转换后的日期
     */
    public static Date stringToDate(String strDate, String format) {
        if (BaseUtil.isEmpty(strDate)) return null;
        if (BaseUtil.isEmpty(format)) format = CommonConstant.DATE_SHORT_FORMAT;
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            return sdf.parse(strDate);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 将字符串转换成日期，默认格式：yyyy-MM-dd
     * 
     * @param strDate - 日期
     * @return Date -转换后的日期
     */
    public static Date stringToDate(String strDate) {
        if (BaseUtil.isEmpty(strDate)) return null;
        return stringToDate(strDate, CommonConstant.DATE_SHORT_FORMAT);
    }

    /**
     * 获取指定日期偏移delayDays后的日期
     * 
     * @param startDate -开始日期
     * @param delayDays -延迟的天数
     * @return Date -转换后的日期
     */
    public static Date getDateAfterDays(Date startDate, int delayDays) {
        if (BaseUtil.isEmpty(startDate)) return null;
        Calendar c = Calendar.getInstance();
        c.setTime(startDate);
        c.add(Calendar.DAY_OF_MONTH, delayDays);
        return c.getTime();
    }

    /**
     * 获取当前日期（没转化格式）
     * 
     * @return Date -转换后的日期
     */
    public static Date getCurrentDate() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        return c.getTime();
    }

    /**
     * getCurrentTime与getLastYearTime组合使用，作为时间限制条件，用于默认返回到当前一年内的数据。
     * 
     */
    /**
     * 获取当前时间，精确到秒（没转化格式）
     * 
     * @return Date -转换后的日期
     */
    public static Date getCurrentTime() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.MILLISECOND, 0);
        return c.getTime();
    }

    /**
     * 获取上一年时间，精确到秒（没转化格式）
     * 
     * @return Date -转换后的日期
     */
    public static Date getLastYearTime() {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, c.get(Calendar.YEAR) - 1);
        c.set(Calendar.MILLISECOND, 0);
        return c.getTime();
    }

    /**
     * 设置开始日期时分秒格式 00:00:00
     * 
     * @param date -日期
     * @return Date -转换后的日期
     */
    public static Date setSatrtDate(Date date) {
        if (BaseUtil.isEmpty(date)) return null;
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        return c.getTime();
    }

    /**
     * 设置结束日期时分秒格式 23:59:59
     * 
     * @param date -日期
     * @return Date -转换后的日期
     */
    public static Date setEndDate(Date date) {
        if (BaseUtil.isEmpty(date)) return null;
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        return c.getTime();
    }

    /**
     * 获取当前年份-长
     * 
     * @return String -当前年份
     */
    public static String getCurrentLongYear() {
        Calendar c = Calendar.getInstance();
        String year = Integer.toString(c.get(Calendar.YEAR));
        return year;
    }

    /**
     * 获取当前年份-短
     * 
     * @return String -当前年份
     */
    public static String getCurrentYear() {
        Calendar c = Calendar.getInstance();
        String year = Integer.toString(c.get(Calendar.YEAR));
        year = year.substring(2);
        return year;
    }

    /**
     * 获取当前月份
     * 
     * @return String -当天月份
     */
    public static String getCurrentMonth() {
        Calendar c = Calendar.getInstance();
        String month = Integer.toString(c.get(Calendar.MONTH) + 1);
        return month;
    }

    public static String getCurrentMonth2() {
        String month = getCurrentMonth();
        return month.length() < 2 ? "0" + month : month;
    }

    /**
     * 获取当天日期
     * 
     * @return String -日期
     */
    public static String getCurrentDay() {
        Calendar c = Calendar.getInstance();
        String date = Integer.toString(c.get(Calendar.DATE));
        if (date.length() < 2) date = "0" + date;
        return date;
    }

    /**
     * 获取指定时间的前一天的指定类型日期
     * 
     * @param date
     * @param format
     * @return String
     */
    public static String getBeforeDay(String date, String format) {
        if (BaseUtil.isEmpty(date)) return null;
        if (BaseUtil.isEmpty(format)) format = CommonConstant.DATE_SHORT_FORMAT;
        Calendar c = Calendar.getInstance();
        c.clear();
        c.setTime(stringToDate(date));
        c.add(Calendar.DATE, -1);
        SimpleDateFormat myFormatter = new SimpleDateFormat(format);
        return myFormatter.format(c.getTime());
    }

    /**
     * 获取指定时间的前一天的默认类型日期
     * 
     * @param date
     * @param format
     * @return String
     */
    public static String getBeforeDay(String date) {
        return getBeforeDay(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
    }

    /**
     * 获取指定时间的后一天的指定类型日期
     * 
     * @param date
     * @param format
     * @return String
     */
    public static String getAfterDay(String date, String format) {
        if (BaseUtil.isEmpty(date)) return null;
        if (BaseUtil.isEmpty(format)) format = CommonConstant.DATE_SHORT_FORMAT;
        Calendar c = Calendar.getInstance();
        c.clear();
        c.setTime(stringToDate(date));
        c.add(Calendar.DATE, 1);
        SimpleDateFormat myFormatter = new SimpleDateFormat(format);
        return myFormatter.format(c.getTime());
    }

    /**
     * 获取指定时间的后n天的指定类型日期
     * 
     * @param date
     * @param format
     * @param days
     * @return
     */
    public static String getAfterDayByDays(String date, String format, int days) {
        if (BaseUtil.isEmpty(date)) return null;
        if (BaseUtil.isEmpty(format)) format = CommonConstant.DATE_SHORT_FORMAT;
        Calendar c = Calendar.getInstance();
        c.clear();
        c.setTime(stringToDate(date));
        c.add(Calendar.DATE, days);
        SimpleDateFormat myFormatter = new SimpleDateFormat(format);
        return myFormatter.format(c.getTime());
    }

    /**
     * 获取指定时间的后一天的默认类型日期
     * 
     * @param date
     * @param format
     * @return String
     */
    public static String getAfterDay(String date) {
        return getAfterDay(date, CommonConstant.DATE_WITHMILLISECOND_FORMAT);
    }

    /**
     * 获取指定时间前一天的最后时间的固定类型日期 yyyy-MM-dd HH:mm:ss
     * 
     * @param String
     * @return String
     */
    public static String getBeforeDayLastTime(String date) {
        if (BaseUtil.isEmpty(date)) return null;
        return dateToString(setEndDate(stringToDate(getBeforeDay(date))), CommonConstant.DATE_WITHSECOND_FORMAT);
    }

    /**
     * 获取指定时间前一天的最后时间的固定类型日期 yyyy-MM-dd HH:mm:ss
     * 
     * @param String
     * @return Date
     */
    public static Date getBeforeDayLastTime(Date date) {
        if (BaseUtil.isEmpty(date)) return null;
        return setEndDate(stringToDate(getBeforeDay(dateToString(date, CommonConstant.DATE_WITHSECOND_FORMAT))));
    }

    /**
     * 获取指定时间后一天的开始时间的固定类型日期 yyyy-MM-dd HH:mm:ss
     * 
     * @param String
     * @return String
     */
    public static String getAfterDayFirstTime(String date) {
        if (BaseUtil.isEmpty(date)) return null;
        return dateToString(setSatrtDate(stringToDate(getAfterDay(date))), CommonConstant.DATE_WITHSECOND_FORMAT);
    }

    /**
     * 获取指定时间后一天的开始时间的固定类型日期 yyyy-MM-dd HH:mm:ss
     * 
     * @param String
     * @return Date
     */
    public static Date getAfterDayFirstTime(Date date) {
        if (BaseUtil.isEmpty(date)) return null;
        return setSatrtDate(stringToDate(getAfterDay(dateToString(date, CommonConstant.DATE_WITHSECOND_FORMAT))));
    }

    /**
     * 根据一个日期，返回是星期几的字符串
     * 
     * @param sdate
     * @return String
     */
    public static String getWeek(String date) {
        if (BaseUtil.isEmpty(date)) return null;
        Date sdate = stringToDate(date, CommonConstant.DATE_SHORT_FORMAT);
        Calendar c = Calendar.getInstance();
        c.setTime(sdate);

        return new SimpleDateFormat("EEEE").format(c.getTime());
    }

    /**
     * 两个时间之间的天数
     * 
     * @param date1
     * @param date2
     * @return
     * @throws ParseException
     */
    public static long getDays(String date1, String date2) throws ParseException {
        if (BaseUtil.isEmpty(date1)) return 0;
        if (BaseUtil.isEmpty(date2)) return 0;
        // 转换为标准时间
        SimpleDateFormat myFormatter = new SimpleDateFormat(CommonConstant.DATE_SHORT_FORMAT);
        Date date = null;
        Date mydate = null;

        date = myFormatter.parse(date1);
        mydate = myFormatter.parse(date2);
        long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
        return (new BigDecimal(day).abs()).longValue();
    }

    /**
     * 给定一个年份判断该年份是否为闰年
     * 
     * @param year
     * @return false:不是闰年 true:闰年
     */
    public static boolean isLeapYear(int year) {
        GregorianCalendar calendar = new GregorianCalendar();
        return calendar.isLeapYear(year);
    }

    /**
     * 获取数据库时间
     * 
     * @return String
     * @throws AGPException
     */
    // public static Date getDBTime() throws FrameworkException {
    // return SystemResourceUtil.getInstance().getDBTime();
    // }

    /**
     * @param int minute 偏移分钟数
     * @return String 返回经偏移后的时间字符串
     */

    public static String getOffsetByMinute(int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MINUTE, calendar.get(Calendar.MINUTE) + minute);
        return dateToString(calendar.getTime(), CommonConstant.DATE_WITHSECOND_FORMAT);
    }

    /**
     * 按照半小时为计数单位
     * 
     * 返回当前计数
     * 
     * @return int
     */
    public static int getHalfHourCnt() {
        Calendar c = Calendar.getInstance();
        // 小时
        int hour = c.get(Calendar.HOUR_OF_DAY);
        // 分钟
        int minute = c.get(Calendar.MINUTE);
        // 如果当前时间大于30分钟，则计数加1
        return (minute >= 30) ? (hour * 2 + 1) : (hour * 2);
    }

    /**
     * @param int halfHour 按照半小时为计数单位
     * 
     *        返回当前计数时段的最大时间(格式yyyy-mm-dd hh:mi:sss)
     * 
     * @return String
     */
    public static String getSelfMaxTime(int halfHour) {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.HOUR_OF_DAY, halfHour / 2);
        c.set(Calendar.MINUTE, halfHour % 2 == 0 ? 29 : 59);
        c.set(Calendar.SECOND, 59);
        return dateToString(c.getTime(), CommonConstant.DATE_WITHSECOND_FORMAT);
    }

    /**
     * 返回当前小时
     * 
     * @return int
     */
    public static int getHour() {
        Calendar c = Calendar.getInstance();
        return c.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 返回当日期
     * 
     * @return int
     */
    public static int getDay() {
        Calendar c = Calendar.getInstance();
        return c.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 返回周内日号
     * 
     * @return int
     */
    public static int getDayOfWeek() {
        Calendar c = Calendar.getInstance();
        int day = c.get(Calendar.DAY_OF_WEEK);
        return (day - 1) > 0 ? (day - 1) : 7;
    }

    /**
     * 得到当前日的最大时间
     * 
     * @return Date
     */
    public static Date getMaxLimitDate(Date curDate) {
        if (curDate == null) return null;
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(curDate.getTime());
        c.set(Calendar.HOUR_OF_DAY, 23);
        c.set(Calendar.MINUTE, 59);
        c.set(Calendar.SECOND, 59);
        return c.getTime();
    }

    /**
     * 得到当前日的最小时间
     * 
     * @return Date
     */
    public static Date getMinLimitDate(Date curDate) {
        if (curDate == null) return null;
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(curDate.getTime());
        c.set(Calendar.HOUR_OF_DAY, 0);
        c.set(Calendar.MINUTE, 0);
        c.set(Calendar.SECOND, 0);
        return c.getTime();
    }

    /**
     * 取得指定月份的最后一天
     * 
     * @param strDate -指定日期月份的第一天 比如：2011-01-01
     * @return
     */
    public static String getMonthEnd2(String strDate) {
        Date date = DateUtil.stringToDate(strDate);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 1);
        calendar.add(Calendar.DAY_OF_YEAR, -1);
        String str = DateUtil.dateToString(calendar.getTime(), CommonConstant.DATE_SHORT_FORMAT);
        return str.substring(str.length() - 2, str.length());
    }

    public static void main(String[] arge) {
        System.out.println(getMonthEnd2("2012-02-01"));
    }
}
